#define _POSIX_C_SOURCE 200809L
/**
 * @file protocol_statemachine.c
 * @brief 104协议状态机管理实现
 * @details 本文件实现了104协议的状态机管理功能，包括连接建立、数据传输、
 *          连接释放等状态管理。实现完整的104协议状态机逻辑。
 * 
 *          主要功能包括：
 *          - 状态管理：管理协议的主要状态（STOPPED、STARTING、STARTED、STOPPING、ERROR）
 *          - 子状态管理：管理协议的详细子状态（IDLE、CONNECTING、CONNECTED、DISCONNECTING、DATA_TRANSFER）
 *          - 事件处理：处理各种协议事件和状态转换
 *          - 超时管理：管理各种超时机制和超时处理
 *          - 状态转换：实现状态之间的安全转换和验证
 *          - 统计信息：记录状态机运行的各种统计数据
 *          - 回调机制：支持状态变化、事件和超时的回调通知
 *          - 线程安全：使用互斥锁和超时线程确保线程安全
 * 
 * @author zyb
 * @date 2025-10-14
 * @version 1.0
 * 
 * @note 本模块是104协议栈的核心组件，负责管理协议的状态转换和生命周期
 * @warning 所有函数都是线程安全的，使用互斥锁保护共享数据
 * @see protocol_statemachine.h
 * @see protocol_types.h
 * @see constants.h
 */

#include "../include/protocol_statemachine.h"
#include "../../common/types/include/constants.h"
#include "../../../../../common/logs/include/logger.h"
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
#include <unistd.h>
#include <sys/time.h>

// 定义模块名称
#define LOG_MODULE_NAME "PROTOCOL_STATEMACHINE"

/* ==================== 状态机私有数据结构 ==================== */

/**
 * @brief 状态机私有数据结构
 * @details 该结构体包含了状态机管理器的所有私有数据，包括配置信息、
 *          状态信息、统计信息、回调函数、线程控制和超时管理等。
 *          所有数据都通过互斥锁进行线程安全保护。
 */
typedef struct {
    /* ==================== 配置和状态管理 ==================== */
    protocol_statemachine_config_t config;    /* 状态机配置参数，包括超时时间、重试次数等 */
    protocol_state_t current_state;           /* 当前主状态：协议的主要运行状态 */
    protocol_substate_t current_substate;     /* 当前子状态：协议的详细运行状态 */
    protocol_statemachine_stats_t stats;      /* 状态机统计信息，记录各种操作次数和状态 */
    
    /* ==================== 回调函数管理 ==================== */
    protocol_state_callback_t state_callback;  /* 状态变化回调函数指针 */
    void* state_user_data;                     /* 状态回调用户数据指针 */
    protocol_event_callback_t event_callback;  /* 事件处理回调函数指针 */
    void* event_user_data;                     /* 事件回调用户数据指针 */
    protocol_statemachine_timeout_callback_t timeout_callback; /* 超时处理回调函数指针 */
    void* timeout_user_data;                   /* 超时回调用户数据指针 */
    
    /* ==================== 线程安全控制 ==================== */
    pthread_t timeout_thread;                 /* 超时监控线程：用于监控各种超时事件 */
    bool thread_running;                      /* 线程运行标志：标识超时线程是否正在运行 */
    pthread_mutex_t mutex;                    /* 互斥锁：保护共享数据的线程安全 */
    
    /* ==================== 超时管理 ==================== */
    struct timeval timeout_start[4];          /* 超时开始时间数组：记录各种超时的开始时间 */
    bool timeout_active[4];                   /* 超时激活标志数组：标识各种超时是否激活 */
    uint32_t timeout_duration[4];             /* 超时持续时间 */
    
    /* 状态机运行标志 */
    bool running;                             /* 状态机运行标志 */
} protocol_statemachine_private_t;

/* ==================== 前向声明 ==================== */

static void protocol_statemachine_change_state(protocol_statemachine_private_t* private_data, 
                                              protocol_state_t new_state);

static void protocol_statemachine_handle_event(protocol_statemachine_private_t* private_data, 
                                              protocol_event_t event, 
                                              const void* event_data);

static void* protocol_statemachine_timeout_thread(void* arg);

/* ==================== 状态机管理函数实现 ==================== */

/**
 * @brief 创建协议状态机管理器
 * @details 创建并初始化一个新的104协议状态机管理器实例。该函数会分配内存、
 *          验证配置参数、初始化内部状态和互斥锁，并设置初始的状态机状态。
 *          状态机管理器负责处理协议状态转换、事件处理、超时管理等功能。
 * 
 * @param config 状态机配置参数指针，不能为NULL
 * 
 * @return 状态机管理器句柄，成功返回有效句柄，失败返回NULL
 * 
 * @note 创建的状态机管理器需要调用protocol_statemachine_destroy()释放资源
 * @warning 配置参数必须通过protocol_statemachine_validate_config()验证
 * @see protocol_statemachine_destroy
 * @see protocol_statemachine_validate_config
 */
protocol_statemachine_handle_t protocol_statemachine_create(const protocol_statemachine_config_t* config) {
    LOG_DEBUG(LOG_MODULE_NAME, "开始创建协议状态机管理器");
    
    if (config == NULL) {
        LOG_ERROR(LOG_MODULE_NAME, "配置参数为空指针");
        return NULL;
    }
    
    LOG_INFO(LOG_MODULE_NAME, "验证状态机配置参数");
    
    // 验证配置
    if (protocol_statemachine_validate_config(config) != PROTOCOL_SUCCESS) {
        LOG_ERROR(LOG_MODULE_NAME, "状态机配置参数验证失败");
        return NULL;
    }
    
    LOG_DEBUG(LOG_MODULE_NAME, "分配状态机管理器内存");
    protocol_statemachine_private_t* private_data = 
        (protocol_statemachine_private_t*)malloc(sizeof(protocol_statemachine_private_t));
    if (private_data == NULL) {
        LOG_ERROR(LOG_MODULE_NAME, "内存分配失败");
        return NULL;
    }
    
    LOG_DEBUG(LOG_MODULE_NAME, "初始化状态机管理器私有数据");
    memset(private_data, 0, sizeof(protocol_statemachine_private_t));
    
    // 复制配置
    memcpy(&private_data->config, config, sizeof(protocol_statemachine_config_t));
    
    // 初始化状态
    private_data->current_state = PROTOCOL_STATE_STOPPED;
    private_data->current_substate = PROTOCOL_SUBSTATE_IDLE;
    
    LOG_INFO(LOG_MODULE_NAME, "初始化状态机状态，主状态: STOPPED, 子状态: IDLE");
    
    // 初始化互斥锁
    LOG_DEBUG(LOG_MODULE_NAME, "初始化互斥锁");
    if (pthread_mutex_init(&private_data->mutex, NULL) != 0) {
        LOG_ERROR(LOG_MODULE_NAME, "互斥锁初始化失败");
        free(private_data);
        return NULL;
    }
    
    // 初始化超时配置
    private_data->timeout_duration[0] = config->t0_timeout;
    private_data->timeout_duration[1] = config->t1_timeout;
    private_data->timeout_duration[2] = config->t2_timeout;
    private_data->timeout_duration[3] = config->t3_timeout;
    
    return (protocol_statemachine_handle_t)private_data;
}

/**
 * @brief 销毁协议状态机管理器
 * @details 销毁协议状态机管理器，释放所有相关资源。该函数会先停止状态机，
 *          然后销毁互斥锁，最后释放内存。销毁后，句柄将不再有效，不应再使用。
 * 
 * @param handle 状态机管理器句柄，不能为NULL
 * 
 * @return 协议错误码
 *         - PROTOCOL_SUCCESS: 销毁成功
 *         - PROTOCOL_ERROR_NULL_POINTER: 句柄为空指针
 * 
 * @note 该函数是线程安全的，会先停止状态机再销毁资源
 * @note 销毁后，句柄将不再有效，不应再使用
 * @warning 销毁后，所有相关的状态机操作都将失败
 * @see protocol_statemachine_create
 * @see protocol_statemachine_stop
 */
protocol_error_t protocol_statemachine_destroy(protocol_statemachine_handle_t handle) {
    LOG_DEBUG(LOG_MODULE_NAME, "开始销毁协议状态机管理器");
    
    if (handle == NULL) {
        LOG_ERROR(LOG_MODULE_NAME, "状态机管理器句柄为空指针");
        return PROTOCOL_ERROR_NULL_POINTER;
    }
    
    protocol_statemachine_private_t* private_data = (protocol_statemachine_private_t*)handle;
    
    LOG_INFO(LOG_MODULE_NAME, "停止状态机管理器");
    // 停止状态机
    protocol_statemachine_stop(handle);
    
    LOG_DEBUG(LOG_MODULE_NAME, "销毁互斥锁");
    // 销毁互斥锁
    pthread_mutex_destroy(&private_data->mutex);
    
    LOG_DEBUG(LOG_MODULE_NAME, "释放状态机管理器内存");
    // 释放内存
    free(private_data);
    
    LOG_INFO(LOG_MODULE_NAME, "状态机管理器销毁完成");
    return PROTOCOL_SUCCESS;
}

/**
 * @brief 启动协议状态机管理器
 * @details 启动协议状态机管理器，开始状态机的运行。该函数会设置运行标志，
 *          启动超时处理线程，并将状态机转换到STARTING状态。如果状态机已经在运行，
 *          则直接返回成功。
 * 
 * @param handle 状态机管理器句柄，不能为NULL
 * 
 * @return 协议错误码
 *         - PROTOCOL_SUCCESS: 启动成功或已经在运行
 *         - PROTOCOL_ERROR_NULL_POINTER: 句柄为空指针
 *         - PROTOCOL_ERROR_SYSTEM_INIT_FAILED: 系统初始化失败（线程创建失败）
 * 
 * @note 该函数是线程安全的，使用互斥锁保护共享数据
 * @note 如果状态机已经在运行，函数会直接返回成功
 * @note 启动后会创建超时处理线程
 * @warning 启动失败时，状态机会保持停止状态
 * @see protocol_statemachine_stop
 * @see protocol_statemachine_timeout_thread
 */
protocol_error_t protocol_statemachine_start(protocol_statemachine_handle_t handle) {
    LOG_DEBUG(LOG_MODULE_NAME, "开始启动协议状态机管理器");
    
    if (handle == NULL) {
        LOG_ERROR(LOG_MODULE_NAME, "状态机管理器句柄为空指针");
        return PROTOCOL_ERROR_NULL_POINTER;
    }
    
    protocol_statemachine_private_t* private_data = (protocol_statemachine_private_t*)handle;
    
    pthread_mutex_lock(&private_data->mutex);
    
    if (private_data->running) {
        LOG_INFO(LOG_MODULE_NAME, "状态机管理器已经在运行");
        pthread_mutex_unlock(&private_data->mutex);
        return PROTOCOL_SUCCESS; // 已经运行
    }
    
    LOG_INFO(LOG_MODULE_NAME, "设置状态机管理器运行标志");
    // 设置运行标志
    private_data->running = true;
    
    LOG_DEBUG(LOG_MODULE_NAME, "启动超时处理线程");
    // 启动超时线程
    private_data->thread_running = true;
    if (pthread_create(&private_data->timeout_thread, NULL, 
                      (void*(*)(void*))protocol_statemachine_timeout_thread, private_data) != 0) {
        LOG_ERROR(LOG_MODULE_NAME, "超时处理线程创建失败");
        private_data->thread_running = false;
        private_data->running = false;
        pthread_mutex_unlock(&private_data->mutex);
        return PROTOCOL_ERROR_SYSTEM_INIT_FAILED;
    }
    
    LOG_INFO(LOG_MODULE_NAME, "转换状态机到STARTING状态");
    // 转换到启动状态
    protocol_statemachine_change_state(private_data, PROTOCOL_STATE_STARTING);
    
    pthread_mutex_unlock(&private_data->mutex);
    
    LOG_INFO(LOG_MODULE_NAME, "状态机管理器启动完成");
    return PROTOCOL_SUCCESS;
}

/**
 * @brief 停止协议状态机管理器
 * @details 停止协议状态机管理器，结束状态机的运行。该函数会设置停止标志，
 *          停止超时处理线程，并将状态机转换到STOPPING状态，然后等待线程结束，
 *          最后转换到STOPPED状态。如果状态机已经停止，则直接返回成功。
 * 
 * @param handle 状态机管理器句柄，不能为NULL
 * 
 * @return 协议错误码
 *         - PROTOCOL_SUCCESS: 停止成功或已经停止
 *         - PROTOCOL_ERROR_NULL_POINTER: 句柄为空指针
 * 
 * @note 该函数是线程安全的，使用互斥锁保护共享数据
 * @note 如果状态机已经停止，函数会直接返回成功
 * @note 停止过程包括等待超时处理线程结束
 * @warning 停止后，状态机将不再处理事件
 * @see protocol_statemachine_start
 * @see protocol_statemachine_timeout_thread
 */
protocol_error_t protocol_statemachine_stop(protocol_statemachine_handle_t handle) {
    LOG_DEBUG(LOG_MODULE_NAME, "开始停止协议状态机管理器");
    
    if (handle == NULL) {
        LOG_ERROR(LOG_MODULE_NAME, "状态机管理器句柄为空指针");
        return PROTOCOL_ERROR_NULL_POINTER;
    }
    
    protocol_statemachine_private_t* private_data = (protocol_statemachine_private_t*)handle;
    
    pthread_mutex_lock(&private_data->mutex);
    
    if (!private_data->running) {
        LOG_INFO(LOG_MODULE_NAME, "状态机管理器已经停止");
        pthread_mutex_unlock(&private_data->mutex);
        return PROTOCOL_SUCCESS; // 已经停止
    }
    
    LOG_INFO(LOG_MODULE_NAME, "设置状态机管理器停止标志");
    // 设置停止标志
    private_data->running = false;
    private_data->thread_running = false;
    
    LOG_INFO(LOG_MODULE_NAME, "转换状态机到STOPPING状态");
    // 转换到停止状态
    protocol_statemachine_change_state(private_data, PROTOCOL_STATE_STOPPING);
    
    pthread_mutex_unlock(&private_data->mutex);
    
    LOG_DEBUG(LOG_MODULE_NAME, "等待超时处理线程结束");
    // 等待超时线程结束
    if (private_data->timeout_thread) {
        pthread_join(private_data->timeout_thread, NULL);
    }
    
    LOG_INFO(LOG_MODULE_NAME, "转换状态机到最终STOPPED状态");
    // 最终转换到停止状态
    pthread_mutex_lock(&private_data->mutex);
    protocol_statemachine_change_state(private_data, PROTOCOL_STATE_STOPPED);
    pthread_mutex_unlock(&private_data->mutex);
    
    LOG_INFO(LOG_MODULE_NAME, "状态机管理器停止完成");
    return PROTOCOL_SUCCESS;
}

/**
 * @brief 处理协议状态机事件
 * @details 处理协议状态机事件，根据当前状态和事件类型进行相应的状态转换。
 *          该函数会先检查状态机是否正在运行，然后调用事件处理回调函数，
 *          最后根据事件和当前状态进行状态转换。该函数是状态机的核心处理函数。
 * 
 * @param handle 状态机管理器句柄，不能为NULL
 * @param event 要处理的事件类型
 * @param event_data 事件数据，可以为NULL
 * 
 * @return 协议错误码
 *         - PROTOCOL_SUCCESS: 事件处理成功
 *         - PROTOCOL_ERROR_NULL_POINTER: 句柄为空指针
 *         - PROTOCOL_ERROR_SYSTEM_NOT_READY: 状态机未运行
 *         - 其他错误码：来自事件处理回调函数
 * 
 * @note 该函数是线程安全的，使用互斥锁保护共享数据
 * @note 事件处理包括回调函数调用和状态转换
 * @note 如果状态机未运行，函数会返回错误
 * @warning 事件处理回调函数应该尽快返回，避免阻塞状态机
 * @see protocol_event_t
 * @see protocol_statemachine_handle_event
 */
protocol_error_t protocol_statemachine_process_event(protocol_statemachine_handle_t handle, 
                                                    protocol_event_t event, 
                                                    const void* event_data) {
    LOG_DEBUG(LOG_MODULE_NAME, "开始处理协议状态机事件，事件类型: %d", event);
    
    if (handle == NULL) {
        LOG_ERROR(LOG_MODULE_NAME, "状态机管理器句柄为空指针");
        return PROTOCOL_ERROR_NULL_POINTER;
    }
    
    protocol_statemachine_private_t* private_data = (protocol_statemachine_private_t*)handle;
    
    pthread_mutex_lock(&private_data->mutex);
    
    if (!private_data->running) {
        LOG_WARN(LOG_MODULE_NAME, "状态机管理器未运行，无法处理事件");
        pthread_mutex_unlock(&private_data->mutex);
        return PROTOCOL_ERROR_SYSTEM_NOT_READY;
    }
    
    LOG_INFO(LOG_MODULE_NAME, "更新事件处理统计信息");
    // 更新统计信息
    private_data->stats.events_processed++;
    
    LOG_DEBUG(LOG_MODULE_NAME, "调用事件处理回调函数");
    // 调用事件处理回调
    protocol_error_t result = PROTOCOL_SUCCESS;
    if (private_data->event_callback) {
        result = private_data->event_callback(event, event_data, private_data->event_user_data);
    }
    
    LOG_DEBUG(LOG_MODULE_NAME, "根据事件和当前状态进行状态转换");
    // 根据事件和当前状态进行状态转换
    protocol_statemachine_handle_event(private_data, event, event_data);
    
    pthread_mutex_unlock(&private_data->mutex);
    
    LOG_INFO(LOG_MODULE_NAME, "事件处理完成，结果: %d", result);
    return result;
}

/* ==================== 状态查询函数实现 ==================== */

/**
 * @brief 获取协议状态机当前主状态
 * @details 获取协议状态机管理器的当前主状态。该函数是线程安全的，
 *          使用互斥锁保护共享数据的访问。
 * 
 * @param handle 状态机管理器句柄，不能为NULL
 * 
 * @return 当前主状态
 *         - 如果句柄为NULL，返回PROTOCOL_STATE_ERROR
 *         - 否则返回当前主状态
 * 
 * @note 该函数是线程安全的
 * @see protocol_state_t
 * @see protocol_statemachine_get_substate
 */
protocol_state_t protocol_statemachine_get_state(protocol_statemachine_handle_t handle) {
    LOG_DEBUG(LOG_MODULE_NAME, "获取协议状态机当前主状态");
    
    if (handle == NULL) {
        LOG_ERROR(LOG_MODULE_NAME, "状态机管理器句柄为空指针");
        return PROTOCOL_STATE_ERROR;
    }
    
    protocol_statemachine_private_t* private_data = (protocol_statemachine_private_t*)handle;
    
    pthread_mutex_lock(&private_data->mutex);
    protocol_state_t state = private_data->current_state;
    pthread_mutex_unlock(&private_data->mutex);
    
    LOG_INFO(LOG_MODULE_NAME, "当前主状态: %d", state);
    return state;
}

/**
 * @brief 获取协议状态机当前子状态
 * @details 获取协议状态机管理器的当前子状态。该函数是线程安全的，
 *          使用互斥锁保护共享数据的访问。
 * 
 * @param handle 状态机管理器句柄，不能为NULL
 * 
 * @return 当前子状态
 *         - 如果句柄为NULL，返回PROTOCOL_SUBSTATE_IDLE
 *         - 否则返回当前子状态
 * 
 * @note 该函数是线程安全的
 * @see protocol_substate_t
 * @see protocol_statemachine_get_state
 */
protocol_substate_t protocol_statemachine_get_substate(protocol_statemachine_handle_t handle) {
    LOG_DEBUG(LOG_MODULE_NAME, "获取协议状态机当前子状态");
    
    if (handle == NULL) {
        LOG_ERROR(LOG_MODULE_NAME, "状态机管理器句柄为空指针");
        return PROTOCOL_SUBSTATE_IDLE;
    }
    
    protocol_statemachine_private_t* private_data = (protocol_statemachine_private_t*)handle;
    
    pthread_mutex_lock(&private_data->mutex);
    protocol_substate_t substate = private_data->current_substate;
    pthread_mutex_unlock(&private_data->mutex);
    
    LOG_INFO(LOG_MODULE_NAME, "当前子状态: %d", substate);
    return substate;
}

/**
 * @brief 获取协议状态机统计信息
 * @details 获取协议状态机管理器的统计信息，包括各种操作的计数和状态。
 *          该函数会复制当前的统计信息到提供的缓冲区中，应用程序可以查看
 *          状态机管理器的运行状态。该函数是线程安全的，使用互斥锁保护。
 * 
 * @param handle 状态机管理器句柄，不能为NULL
 * @param stats 统计信息输出缓冲区，不能为NULL
 * 
 * @return 协议错误码
 *         - PROTOCOL_SUCCESS: 获取成功
 *         - PROTOCOL_ERROR_NULL_POINTER: 参数为空指针
 * 
 * @note 该函数是线程安全的，使用互斥锁保护共享数据
 * @note 获取的统计信息是当前时刻的快照
 * @see protocol_statemachine_stats_t
 */
protocol_error_t protocol_statemachine_get_stats(protocol_statemachine_handle_t handle, 
                                                protocol_statemachine_stats_t* stats) {
    LOG_DEBUG(LOG_MODULE_NAME, "获取协议状态机统计信息");
    
    if (handle == NULL || stats == NULL) {
        LOG_ERROR(LOG_MODULE_NAME, "参数为空指针");
        return PROTOCOL_ERROR_NULL_POINTER;
    }
    
    protocol_statemachine_private_t* private_data = (protocol_statemachine_private_t*)handle;
    
    pthread_mutex_lock(&private_data->mutex);
    memcpy(stats, &private_data->stats, sizeof(protocol_statemachine_stats_t));
    pthread_mutex_unlock(&private_data->mutex);
    
    LOG_INFO(LOG_MODULE_NAME, "统计信息获取成功");
    return PROTOCOL_SUCCESS;
}

/* ==================== 回调设置函数实现 ==================== */

/**
 * @brief 设置状态变化回调函数
 * @details 设置状态机状态变化时的回调函数。当状态机的主状态或子状态发生变化时，
 *          系统会自动调用此回调函数通知应用程序。应用程序可以在此函数中处理各种
 *          状态变化事件，实现自定义的状态变化处理逻辑。
 * 
 * @param handle 状态机管理器句柄，不能为NULL
 * @param callback 状态变化处理回调函数指针，可以为NULL（表示取消回调）
 * @param user_data 用户数据指针，会传递给回调函数，可以为NULL
 * 
 * @return 协议错误码
 *         - PROTOCOL_SUCCESS: 设置成功
 *         - PROTOCOL_ERROR_NULL_POINTER: 句柄为空指针
 * 
 * @note 该函数是线程安全的，使用互斥锁保护共享数据
 * @note 如果callback为NULL，则取消状态变化回调
 * @warning 回调函数应该尽快返回，避免阻塞状态机
 * @see protocol_state_callback_t
 * @see protocol_statemachine_set_event_callback
 * @see protocol_statemachine_set_timeout_callback
 */
protocol_error_t protocol_statemachine_set_state_callback(protocol_statemachine_handle_t handle, 
                                                         protocol_state_callback_t callback, 
                                                         void* user_data) {
    LOG_DEBUG(LOG_MODULE_NAME, "设置状态变化回调函数");
    
    if (handle == NULL) {
        LOG_ERROR(LOG_MODULE_NAME, "状态机管理器句柄为空指针");
        return PROTOCOL_ERROR_NULL_POINTER;
    }
    
    protocol_statemachine_private_t* private_data = (protocol_statemachine_private_t*)handle;
    
    pthread_mutex_lock(&private_data->mutex);
    private_data->state_callback = callback;
    private_data->state_user_data = user_data;
    pthread_mutex_unlock(&private_data->mutex);
    
    LOG_INFO(LOG_MODULE_NAME, "状态变化回调函数设置成功");
    return PROTOCOL_SUCCESS;
}

/**
 * @brief 设置事件处理回调函数
 * @details 设置状态机事件处理时的回调函数。当状态机接收到事件时，
 *          系统会自动调用此回调函数通知应用程序。应用程序可以在此函数中处理各种
 *          事件，实现自定义的事件处理逻辑。
 * 
 * @param handle 状态机管理器句柄，不能为NULL
 * @param callback 事件处理回调函数指针，可以为NULL（表示取消回调）
 * @param user_data 用户数据指针，会传递给回调函数，可以为NULL
 * 
 * @return 协议错误码
 *         - PROTOCOL_SUCCESS: 设置成功
 *         - PROTOCOL_ERROR_NULL_POINTER: 句柄为空指针
 * 
 * @note 该函数是线程安全的，使用互斥锁保护共享数据
 * @note 如果callback为NULL，则取消事件处理回调
 * @warning 回调函数应该尽快返回，避免阻塞状态机
 * @see protocol_event_callback_t
 * @see protocol_statemachine_set_state_callback
 * @see protocol_statemachine_set_timeout_callback
 */
protocol_error_t protocol_statemachine_set_event_callback(protocol_statemachine_handle_t handle, 
                                                         protocol_event_callback_t callback, 
                                                         void* user_data) {
    LOG_DEBUG(LOG_MODULE_NAME, "设置事件处理回调函数");
    
    if (handle == NULL) {
        LOG_ERROR(LOG_MODULE_NAME, "状态机管理器句柄为空指针");
        return PROTOCOL_ERROR_NULL_POINTER;
    }
    
    protocol_statemachine_private_t* private_data = (protocol_statemachine_private_t*)handle;
    
    pthread_mutex_lock(&private_data->mutex);
    private_data->event_callback = callback;
    private_data->event_user_data = user_data;
    pthread_mutex_unlock(&private_data->mutex);
    
    LOG_INFO(LOG_MODULE_NAME, "事件处理回调函数设置成功");
    return PROTOCOL_SUCCESS;
}

/**
 * @brief 设置超时回调函数
 * @details 设置状态机超时发生时的回调函数。当状态机的超时定时器触发时，
 *          系统会自动调用此回调函数通知应用程序。应用程序可以在此函数中处理各种
 *          超时事件，实现自定义的超时处理逻辑。
 * 
 * @param handle 状态机管理器句柄，不能为NULL
 * @param callback 超时处理回调函数指针，可以为NULL（表示取消回调）
 * @param user_data 用户数据指针，会传递给回调函数，可以为NULL
 * 
 * @return 协议错误码
 *         - PROTOCOL_SUCCESS: 设置成功
 *         - PROTOCOL_ERROR_NULL_POINTER: 句柄为空指针
 * 
 * @note 该函数是线程安全的，使用互斥锁保护共享数据
 * @note 如果callback为NULL，则取消超时回调
 * @warning 回调函数应该尽快返回，避免阻塞状态机
 * @see protocol_statemachine_timeout_callback_t
 * @see protocol_statemachine_set_state_callback
 * @see protocol_statemachine_set_event_callback
 */
protocol_error_t protocol_statemachine_set_timeout_callback(protocol_statemachine_handle_t handle, 
                                                           protocol_statemachine_timeout_callback_t callback, 
                                                           void* user_data) {
    LOG_DEBUG(LOG_MODULE_NAME, "设置超时回调函数");
    
    if (handle == NULL) {
        LOG_ERROR(LOG_MODULE_NAME, "状态机管理器句柄为空指针");
        return PROTOCOL_ERROR_NULL_POINTER;
    }
    
    protocol_statemachine_private_t* private_data = (protocol_statemachine_private_t*)handle;
    
    pthread_mutex_lock(&private_data->mutex);
    private_data->timeout_callback = callback;
    private_data->timeout_user_data = user_data;
    pthread_mutex_unlock(&private_data->mutex);
    
    LOG_INFO(LOG_MODULE_NAME, "超时回调函数设置成功");
    return PROTOCOL_SUCCESS;
}

/* ==================== 超时管理函数实现 ==================== */

/**
 * @brief 启动协议状态机超时定时器
 * @details 启动指定类型的超时定时器。该函数会设置指定超时类型的启动时间，
 *          超时处理线程会定期检查并触发超时事件。支持T0、T1、T2、T3四种超时类型。
 *          该函数是线程安全的，使用互斥锁保护共享数据。
 * 
 * @param handle 状态机管理器句柄，不能为NULL
 * @param timeout_type 超时类型，取值范围0-3
 *                     - 0: T0超时（连接建立超时）
 *                     - 1: T1超时（发送或测试帧超时）
 *                     - 2: T2超时（确认超时）
 *                     - 3: T3超时（发送或测试帧超时）
 * 
 * @return 协议错误码
 *         - PROTOCOL_SUCCESS: 启动成功
 *         - PROTOCOL_ERROR_NULL_POINTER: 句柄为空指针
 *         - PROTOCOL_ERROR_INVALID_PARAM: 超时类型无效
 * 
 * @note 该函数是线程安全的，使用互斥锁保护共享数据
 * @note 超时时间由配置参数中的对应值决定
 * @warning 超时类型必须在有效范围内（0-3）
 * @see protocol_statemachine_stop_timeout
 * @see protocol_statemachine_reset_timeout
 */
protocol_error_t protocol_statemachine_start_timeout(protocol_statemachine_handle_t handle, 
                                                    uint32_t timeout_type) {
    LOG_DEBUG(LOG_MODULE_NAME, "启动超时定时器，类型: %d", timeout_type);
    
    if (handle == NULL || timeout_type >= 4) {
        LOG_ERROR(LOG_MODULE_NAME, "参数无效，句柄: %p, 超时类型: %d", handle, timeout_type);
        return PROTOCOL_ERROR_INVALID_PARAM;
    }
    
    protocol_statemachine_private_t* private_data = (protocol_statemachine_private_t*)handle;
    
    pthread_mutex_lock(&private_data->mutex);
    
    LOG_INFO(LOG_MODULE_NAME, "记录超时开始时间，类型: %d", timeout_type);
    // 记录超时开始时间
    gettimeofday(&private_data->timeout_start[timeout_type], NULL);
    private_data->timeout_active[timeout_type] = true;
    
    pthread_mutex_unlock(&private_data->mutex);
    
    LOG_INFO(LOG_MODULE_NAME, "超时定时器启动成功，类型: %d", timeout_type);
    return PROTOCOL_SUCCESS;
}

/**
 * @brief 停止协议状态机超时定时器
 * @details 停止指定类型的超时定时器。该函数会清除指定超时类型的启动时间，
 *          使超时处理线程不再检查该类型的超时。支持T0、T1、T2、T3四种超时类型。
 *          该函数是线程安全的，使用互斥锁保护共享数据。
 * 
 * @param handle 状态机管理器句柄，不能为NULL
 * @param timeout_type 超时类型，取值范围0-3
 *                     - 0: T0超时（连接建立超时）
 *                     - 1: T1超时（发送或测试帧超时）
 *                     - 2: T2超时（确认超时）
 *                     - 3: T3超时（发送或测试帧超时）
 * 
 * @return 协议错误码
 *         - PROTOCOL_SUCCESS: 停止成功
 *         - PROTOCOL_ERROR_NULL_POINTER: 句柄为空指针
 *         - PROTOCOL_ERROR_INVALID_PARAM: 超时类型无效
 * 
 * @note 该函数是线程安全的，使用互斥锁保护共享数据
 * @note 停止后，该类型的超时事件将不再触发
 * @warning 超时类型必须在有效范围内（0-3）
 * @see protocol_statemachine_start_timeout
 * @see protocol_statemachine_reset_timeout
 */
protocol_error_t protocol_statemachine_stop_timeout(protocol_statemachine_handle_t handle, 
                                                   uint32_t timeout_type) {
    LOG_DEBUG(LOG_MODULE_NAME, "停止超时定时器，类型: %d", timeout_type);
    
    if (handle == NULL || timeout_type >= 4) {
        LOG_ERROR(LOG_MODULE_NAME, "参数无效，句柄: %p, 超时类型: %d", handle, timeout_type);
        return PROTOCOL_ERROR_INVALID_PARAM;
    }
    
    protocol_statemachine_private_t* private_data = (protocol_statemachine_private_t*)handle;
    
    pthread_mutex_lock(&private_data->mutex);
    private_data->timeout_active[timeout_type] = false;
    pthread_mutex_unlock(&private_data->mutex);
    
    LOG_INFO(LOG_MODULE_NAME, "超时定时器停止成功，类型: %d", timeout_type);
    return PROTOCOL_SUCCESS;
}

/**
 * @brief 重置协议状态机超时定时器
 * @details 重置指定类型的超时定时器。该函数会重新设置指定超时类型的启动时间，
 *          相当于先停止再启动该超时定时器。支持T0、T1、T2、T3四种超时类型。
 *          该函数是线程安全的，使用互斥锁保护共享数据。
 * 
 * @param handle 状态机管理器句柄，不能为NULL
 * @param timeout_type 超时类型，取值范围0-3
 *                     - 0: T0超时（连接建立超时）
 *                     - 1: T1超时（发送或测试帧超时）
 *                     - 2: T2超时（确认超时）
 *                     - 3: T3超时（发送或测试帧超时）
 * 
 * @return 协议错误码
 *         - PROTOCOL_SUCCESS: 重置成功
 *         - PROTOCOL_ERROR_NULL_POINTER: 句柄为空指针
 *         - PROTOCOL_ERROR_INVALID_PARAM: 超时类型无效
 * 
 * @note 该函数是线程安全的，使用互斥锁保护共享数据
 * @note 重置会重新开始计时，超时时间由配置参数中的对应值决定
 * @warning 超时类型必须在有效范围内（0-3）
 * @see protocol_statemachine_start_timeout
 * @see protocol_statemachine_stop_timeout
 */
protocol_error_t protocol_statemachine_reset_timeout(protocol_statemachine_handle_t handle, 
                                                    uint32_t timeout_type) {
    LOG_DEBUG(LOG_MODULE_NAME, "重置超时定时器，类型: %d", timeout_type);
    
    if (handle == NULL || timeout_type >= 4) {
        LOG_ERROR(LOG_MODULE_NAME, "参数无效，句柄: %p, 超时类型: %d", handle, timeout_type);
        return PROTOCOL_ERROR_INVALID_PARAM;
    }
    
    protocol_statemachine_private_t* private_data = (protocol_statemachine_private_t*)handle;
    
    pthread_mutex_lock(&private_data->mutex);
    
    if (private_data->timeout_active[timeout_type]) {
        LOG_INFO(LOG_MODULE_NAME, "重新设置超时开始时间，类型: %d", timeout_type);
        gettimeofday(&private_data->timeout_start[timeout_type], NULL);
    } else {
        LOG_INFO(LOG_MODULE_NAME, "超时定时器未激活，无需重置，类型: %d", timeout_type);
    }
    
    pthread_mutex_unlock(&private_data->mutex);
    
    LOG_INFO(LOG_MODULE_NAME, "超时定时器重置完成，类型: %d", timeout_type);
    return PROTOCOL_SUCCESS;
}

/* ==================== 辅助函数实现 ==================== */

/**
 * @brief 获取协议状态名称字符串
 * @details 将协议状态枚举值转换为对应的字符串名称，用于日志记录和调试。
 *          该函数返回静态字符串数组中的对应项，返回的字符串指针在程序
 *          运行期间保持有效，不需要释放内存。
 * 
 * @param state 协议状态枚举值
 * 
 * @return 状态名称字符串
 *         - "STOPPED": 停止状态
 *         - "STARTING": 启动状态
 *         - "STARTED": 已启动状态
 *         - "STOPPING": 停止中状态
 *         - "ERROR": 错误状态
 *         - "UNKNOWN": 未知状态（当state值无效时）
 * 
 * @note 返回的字符串指针是静态的，不需要释放内存
 * @note 该函数是线程安全的，只读取静态数据
 * @see protocol_state_t
 * @see protocol_statemachine_get_substate_name
 * @see protocol_statemachine_get_event_name
 */
const char* protocol_statemachine_get_state_name(protocol_state_t state) {
    static const char* state_names[] = {
        "STOPPED",
        "STARTING", 
        "STARTED",
        "STOPPING",
        "ERROR"
    };
    
    if (state >= sizeof(state_names) / sizeof(state_names[0])) {
        return "UNKNOWN";
    }
    
    return state_names[state];
}

/**
 * @brief 获取协议子状态名称字符串
 * @details 将协议子状态枚举值转换为对应的字符串名称，用于日志记录和调试。
 *          该函数返回静态字符串数组中的对应项，返回的字符串指针在程序
 *          运行期间保持有效，不需要释放内存。
 * 
 * @param substate 协议子状态枚举值
 * 
 * @return 子状态名称字符串
 *         - "IDLE": 空闲子状态
 *         - "CONNECTING": 连接中子状态
 *         - "CONNECTED": 已连接子状态
 *         - "DISCONNECTING": 断开中子状态
 *         - "DATA_TRANSFER": 数据传输子状态
 *         - "UNKNOWN": 未知子状态（当substate值无效时）
 * 
 * @note 返回的字符串指针是静态的，不需要释放内存
 * @note 该函数是线程安全的，只读取静态数据
 * @see protocol_substate_t
 * @see protocol_statemachine_get_state_name
 * @see protocol_statemachine_get_event_name
 */
const char* protocol_statemachine_get_substate_name(protocol_substate_t substate) {
    static const char* substate_names[] = {
        "IDLE",
        "CONNECTING",
        "CONNECTED", 
        "DISCONNECTING",
        "DATA_TRANSFER"
    };
    
    if (substate >= sizeof(substate_names) / sizeof(substate_names[0])) {
        return "UNKNOWN";
    }
    
    return substate_names[substate];
}

/**
 * @brief 获取协议事件名称字符串
 * @details 将协议事件枚举值转换为对应的字符串名称，用于日志记录和调试。
 *          该函数返回静态字符串数组中的对应项，返回的字符串指针在程序
 *          运行期间保持有效，不需要释放内存。
 * 
 * @param event 协议事件枚举值
 * 
 * @return 事件名称字符串
 *         - "START": 启动事件
 *         - "STOP": 停止事件
 *         - "CONNECT": 连接事件
 *         - "DISCONNECT": 断开事件
 *         - "DATA_RECEIVED": 数据接收事件
 *         - "DATA_SENT": 数据发送事件
 *         - "TIMEOUT": 超时事件
 *         - "ERROR": 错误事件
 *         - "UNKNOWN": 未知事件（当event值无效时）
 * 
 * @note 返回的字符串指针是静态的，不需要释放内存
 * @note 该函数是线程安全的，只读取静态数据
 * @see protocol_event_t
 * @see protocol_statemachine_get_state_name
 * @see protocol_statemachine_get_substate_name
 */
const char* protocol_statemachine_get_event_name(protocol_event_t event) {
    static const char* event_names[] = {
        "START",
        "STOP",
        "CONNECT",
        "DISCONNECT",
        "DATA_RECEIVED",
        "DATA_SENT",
        "TIMEOUT",
        "ERROR"
    };
    
    if (event >= sizeof(event_names) / sizeof(event_names[0])) {
        return "UNKNOWN";
    }
    
    return event_names[event];
}

/**
 * @brief 验证协议状态机配置参数的有效性
 * @details 验证协议状态机配置参数是否符合104协议的要求和系统限制。
 *          该函数会检查所有必要的配置参数，确保它们的值在有效范围内。
 *          验证包括超时时间、K值、W值、重试次数等关键参数的合理性检查。
 * 
 * @param config 待验证的状态机配置参数，不能为NULL
 * 
 * @return 协议错误码
 *         - PROTOCOL_SUCCESS: 配置验证通过
 *         - PROTOCOL_ERROR_NULL_POINTER: 配置参数为空指针
 *         - PROTOCOL_ERROR_INVALID_PARAM: 配置参数无效
 * 
 * @note 该函数是线程安全的，只读取配置数据
 * @note 验证规则：
 *       - 超时时间必须大于0
 *       - K值必须在1-32767范围内
 *       - W值必须在1-32767范围内
 *       - 最大重试次数必须大于0
 * @see protocol_statemachine_config_t
 * @see protocol_statemachine_create
 */
protocol_error_t protocol_statemachine_validate_config(const protocol_statemachine_config_t* config) {
    LOG_DEBUG(LOG_MODULE_NAME, "验证状态机配置参数");
    
    if (config == NULL) {
        LOG_ERROR(LOG_MODULE_NAME, "配置参数为空指针");
        return PROTOCOL_ERROR_NULL_POINTER;
    }
    
    LOG_DEBUG(LOG_MODULE_NAME, "检查超时时间配置");
    if (config->t0_timeout == 0 || config->t1_timeout == 0 || 
        config->t2_timeout == 0 || config->t3_timeout == 0) {
        LOG_ERROR(LOG_MODULE_NAME, "超时时间配置无效，T0:%d, T1:%d, T2:%d, T3:%d", 
                  config->t0_timeout, config->t1_timeout, config->t2_timeout, config->t3_timeout);
        return PROTOCOL_ERROR_INVALID_PARAM;
    }
    
    LOG_DEBUG(LOG_MODULE_NAME, "检查K值和W值配置");
    if (config->k_value == 0 || config->w_value == 0) {
        LOG_ERROR(LOG_MODULE_NAME, "K值或W值配置无效，K:%d, W:%d", config->k_value, config->w_value);
        return PROTOCOL_ERROR_INVALID_PARAM;
    }
    
    LOG_INFO(LOG_MODULE_NAME, "状态机配置参数验证通过");
    return PROTOCOL_SUCCESS;
}

/* ==================== 内部函数实现 ==================== */

/**
 * @brief 协议状态机状态变化处理内部函数
 * @details 处理协议状态机的状态变化，更新当前状态，增加状态变化计数，
 *          并调用状态变化回调函数。该函数是内部函数，由其他状态机函数调用。
 * 
 * @param private_data 状态机管理器私有数据，不能为NULL
 * @param new_state 新的状态
 * 
 * @note 该函数是线程安全的，调用者需要确保已持有互斥锁
 * @note 如果新状态与当前状态相同，函数会直接返回
 * @note 状态变化会触发回调函数调用
 * @see protocol_state_t
 * @see protocol_statemachine_handle_event
 */
static void protocol_statemachine_change_state(protocol_statemachine_private_t* private_data, 
                                              protocol_state_t new_state) {
    if (private_data->current_state == new_state) {
        LOG_DEBUG(LOG_MODULE_NAME, "状态没有变化，当前状态: %s", 
                  protocol_statemachine_get_state_name(new_state));
        return; // 状态没有变化
    }
    
    protocol_state_t old_state = private_data->current_state;
    private_data->current_state = new_state;
    private_data->stats.state_changes++;
    
    LOG_INFO(LOG_MODULE_NAME, "状态变化: %s -> %s", 
             protocol_statemachine_get_state_name(old_state),
             protocol_statemachine_get_state_name(new_state));
    
    // 调用状态变化回调
    if (private_data->state_callback) {
        LOG_DEBUG(LOG_MODULE_NAME, "调用状态变化回调函数");
        private_data->state_callback(old_state, new_state, private_data->state_user_data);
    }
}

/**
 * @brief 协议状态机事件处理内部函数
 * @details 根据当前状态和事件类型进行状态转换和子状态更新。该函数实现了
 *          104协议状态机的核心逻辑，包括状态转换规则和子状态管理。
 *          该函数是内部函数，由其他状态机函数调用。
 * 
 * @param private_data 状态机管理器私有数据，不能为NULL
 * @param event 要处理的事件类型
 * @param event_data 事件数据，可以为NULL
 * 
 * @note 该函数是线程安全的，调用者需要确保已持有互斥锁
 * @note 事件处理包括状态转换和子状态更新
 * @note 未处理的事件会被忽略
 * @see protocol_event_t
 * @see protocol_state_t
 * @see protocol_substate_t
 * @see protocol_statemachine_change_state
 */
static void protocol_statemachine_handle_event(protocol_statemachine_private_t* private_data, 
                                              protocol_event_t event, 
                                              const void* event_data) {
    (void)event_data; // 避免未使用参数警告
    
    LOG_DEBUG(LOG_MODULE_NAME, "处理事件: %s, 当前状态: %s", 
              protocol_statemachine_get_event_name(event),
              protocol_statemachine_get_state_name(private_data->current_state));
    
    switch (private_data->current_state) {
        case PROTOCOL_STATE_STOPPED:
            if (event == PROTOCOL_EVENT_START) {
                LOG_INFO(LOG_MODULE_NAME, "STOPPED状态处理START事件");
                protocol_statemachine_change_state(private_data, PROTOCOL_STATE_STARTING);
            }
            break;
            
        case PROTOCOL_STATE_STARTING:
            if (event == PROTOCOL_EVENT_CONNECT) {
                LOG_INFO(LOG_MODULE_NAME, "STARTING状态处理CONNECT事件");
                protocol_statemachine_change_state(private_data, PROTOCOL_STATE_STARTED);
                private_data->current_substate = PROTOCOL_SUBSTATE_CONNECTING;
            } else if (event == PROTOCOL_EVENT_ERROR) {
                LOG_INFO(LOG_MODULE_NAME, "STARTING状态处理ERROR事件");
                protocol_statemachine_change_state(private_data, PROTOCOL_STATE_ERROR);
            }
            break;
            
        case PROTOCOL_STATE_STARTED:
            switch (event) {
                case PROTOCOL_EVENT_CONNECT:
                    LOG_INFO(LOG_MODULE_NAME, "STARTED状态处理CONNECT事件");
                    private_data->current_substate = PROTOCOL_SUBSTATE_CONNECTED;
                    break;
                case PROTOCOL_EVENT_DISCONNECT:
                    LOG_INFO(LOG_MODULE_NAME, "STARTED状态处理DISCONNECT事件");
                    private_data->current_substate = PROTOCOL_SUBSTATE_DISCONNECTING;
                    break;
                case PROTOCOL_EVENT_DATA_RECEIVED:
                case PROTOCOL_EVENT_DATA_SENT:
                    LOG_INFO(LOG_MODULE_NAME, "STARTED状态处理数据事件");
                    private_data->current_substate = PROTOCOL_SUBSTATE_DATA_TRANSFER;
                    break;
                case PROTOCOL_EVENT_STOP:
                    LOG_INFO(LOG_MODULE_NAME, "STARTED状态处理STOP事件");
                    protocol_statemachine_change_state(private_data, PROTOCOL_STATE_STOPPING);
                    break;
                case PROTOCOL_EVENT_ERROR:
                    LOG_INFO(LOG_MODULE_NAME, "STARTED状态处理ERROR事件");
                    protocol_statemachine_change_state(private_data, PROTOCOL_STATE_ERROR);
                    break;
                default:
                    LOG_DEBUG(LOG_MODULE_NAME, "STARTED状态忽略事件: %s", 
                              protocol_statemachine_get_event_name(event));
                    break;
            }
            break;
            
        case PROTOCOL_STATE_STOPPING:
            if (event == PROTOCOL_EVENT_DISCONNECT) {
                LOG_INFO(LOG_MODULE_NAME, "STOPPING状态处理DISCONNECT事件");
                protocol_statemachine_change_state(private_data, PROTOCOL_STATE_STOPPED);
                private_data->current_substate = PROTOCOL_SUBSTATE_IDLE;
            }
            break;
            
        case PROTOCOL_STATE_ERROR:
            if (event == PROTOCOL_EVENT_STOP) {
                LOG_INFO(LOG_MODULE_NAME, "ERROR状态处理STOP事件");
                protocol_statemachine_change_state(private_data, PROTOCOL_STATE_STOPPED);
                private_data->current_substate = PROTOCOL_SUBSTATE_IDLE;
            }
            break;
            
        default:
            LOG_WARN(LOG_MODULE_NAME, "未知状态: %d", private_data->current_state);
            break;
    }
}

/**
 * @brief 协议状态机超时处理线程内部函数
 * @details 超时处理线程的主函数，定期检查所有激活的超时定时器，
 *          当超时发生时触发超时回调和超时事件。该函数运行在独立线程中，
 *          直到线程运行标志被清除。
 * 
 * @param arg 状态机管理器私有数据指针，不能为NULL
 * 
 * @return 线程返回值，通常为NULL
 * 
 * @note 该函数运行在独立线程中，需要与主线程同步
 * @note 线程会定期检查超时状态，检查间隔为1ms
 * @note 超时检查使用互斥锁保护共享数据
 * @warning 该函数会持续运行直到thread_running标志被清除
 * @see protocol_statemachine_start
 * @see protocol_statemachine_stop
 */
static void* protocol_statemachine_timeout_thread(void* arg) {
    protocol_statemachine_private_t* private_data = (protocol_statemachine_private_t*)arg;
    
    LOG_INFO(LOG_MODULE_NAME, "超时处理线程启动");
    
    while (private_data->thread_running) {
        pthread_mutex_lock(&private_data->mutex);
        
        // 检查所有激活的超时
        for (int i = 0; i < 4; i++) {
            if (private_data->timeout_active[i]) {
                struct timeval current_time;
                gettimeofday(&current_time, NULL);
                
                // 计算经过的时间
                long elapsed_ms = (current_time.tv_sec - private_data->timeout_start[i].tv_sec) * 1000 +
                                 (current_time.tv_usec - private_data->timeout_start[i].tv_usec) / 1000;
                
                if (elapsed_ms >= private_data->timeout_duration[i]) {
                    // 超时发生
                    LOG_INFO(LOG_MODULE_NAME, "超时发生，类型: %d, 经过时间: %ld ms", i, elapsed_ms);
                    private_data->timeout_active[i] = false;
                    private_data->stats.timeouts_occurred++;
                    
                    // 调用超时回调
                    if (private_data->timeout_callback) {
                        LOG_DEBUG(LOG_MODULE_NAME, "调用超时回调函数，类型: %d", i);
                        private_data->timeout_callback(i, private_data->timeout_user_data);
                    }
                    
                    // 发送超时事件
                    LOG_DEBUG(LOG_MODULE_NAME, "发送超时事件，类型: %d", i);
                    protocol_statemachine_handle_event(private_data, PROTOCOL_EVENT_TIMEOUT, &i);
                }
            }
        }
        
        pthread_mutex_unlock(&private_data->mutex);
        
        // 短暂休眠
        struct timespec ts = {0, 1000000}; // 1ms
        nanosleep(&ts, NULL);
    }
    
    LOG_INFO(LOG_MODULE_NAME, "超时处理线程结束");
    return NULL;
}
